﻿//#include <iostream>
//using namespace std;
//
//int main()
//{
//    int N;
//    while (cin >> N, N)
//    {
//        int matrix[101][101];
//
//        // 初始化矩阵
//        for (int i = 0; i < N ; i++) {
//            for (int j = 0; j < N ; j++) {
//                matrix[i][j] = 1;
//            }
//        }
//
//        // 填充字符
//        int ch = 1;
//        for (int layer = 0; layer < N; layer++) 
//        {
//            for (int i = layer; i < N  - 1 - layer; i++)
//            {
//                for (int j = layer; j < N  - 1 - layer; j++)
//                {
//                    matrix[i][j] = ch;
//                }
//            }
//            ch++;
//        }
//
//        // 输出矩阵
//        for (int i = 0; i < N ; i++) {
//            for (int j = 0; j < N ; j++) {
//                cout << matrix[i][j];
//            }
//            cout << endl;
//        }
//    }
//    return 0;
//}



//这段代码是实现矩阵的填充和输出，但是它不符合你所期望的结果。

//让我们来看一下代码的实现：首先，该程序定义了一个二维数组 matrix，大小为 N × N。然后，程序将矩阵的所有元素初始化为 1。接下来，程序使用三重循环来填充字符，循环变量 layer 控制了当前处理的层数，每一层都从左上角开始，按照顺时针的方向进行填充，最后将字符 ch 加一。最后，程序使用两重循环输出整个矩阵。

//根据代码实现，程序无法输出你所期望的结果，因为程序中的填充字符的循环是从 layer 开始，而在第一层时 layer 的值为 0，导致第一行第一列的元素没有被填充为 1。如果需要输出你所期望的结果，需要对填充字符的循环进行更改，可以将内层循环的起始和结束位置改为 layer 到 N - 1 - layer，这样就能正确地填充矩阵了。修改后的代码如下所示：

//c++
//#include <iostream>
//using namespace std;
//
//int main()
//{
//    int N;
//    while (cin >> N, N)
//    {
//        int matrix[101][101];
//
//        // 初始化矩阵
//        for (int i = 0; i < N; i++) {
//            for (int j = 0; j < N; j++) {
//                matrix[i][j] = 1;
//            }
//        }
//
//        // 填充字符
//        int ch = 1;
//        for (int layer = 0; layer < N; layer++)
//        {
//            for (int i = layer; i < N - layer; i++)
//            {
//                for (int j = layer; j < N - layer; j++)
//                {
//                    matrix[i][j] = ch;
//                }
//            }
//            ch++;
//        }
//
//        // 输出矩阵
//        for (int i = 0; i < N; i++) {
//            for (int j = 0; j < N; j++) {
//                cout << matrix[i][j] << " ";
//            }
//            cout << endl;
//        }
//    }
//    return 0;
//}
//#include <stdio.h>
//int main(void)
//{
//    int i, j, x = 0;
//    for (i = 0; i < 2; i++) {
//        x++;
//        for (j = 0; j <= 3; j++) {
//            if (j % 2)
//                continue;
//            x++;
//        }
//        x++;
//    }
//    printf("x=%d\n", x);
//    return 0;
//}

//#include<bits/stdc++.h>
//using namespace std;
//int main()
//{
//    int n;
//    cin >> n;
//    double sum = 0;
//    for (double i = 1; i <= n; i++)
//    {
//        sum += 1 / i;
//    }
//    printf("%.6lf", sum);
//    return 0;
//}

//滑动窗口
//#include<bits/stdc++.h>
//using namespace std; 
//int main()
//{
//	
//
//
//	return 0;
//}
//
//
//class Solution
//{
//public:
//	int minSubArraylen(int target, vector<int>& nums)
//	{
//		int n = nums.size(), sum = 0, len = INT_MAX;
//		for (int left = 0, right = 0; right < n; right++)
//		{
//			sum += nums[right];//进窗口
//			while (sum >= target)//判断
//			{
//				len = min{ len,right - left + 1 };
//				sum -= nums[left++];
//			}
//		}
//		return len == INT_MAX ? 0 : len;
//	}
//};
//#include<bits/stdc++.h>
//using namespace std;
//int main()
//{
//	
//	int n = 4, s;
//	s = (1 / 2) * n * (n + 1);
//	printf("%d\n", s);
//	return 0;
//}
//#include<bits/stdc++.h>
//using namespace std;
//
//class Solution
//{
//public:
//	void moveZeroes(vector<int>& nums)
//	{
//		for (int cur = 0, dest = -1; cur < nums.size(); cur++)
//		{
//			if (nums[cur])//非零,就交换
//			{
//				swap(nums[dest++], nums[cur]);
//			}
//		}
//	}
//};

//复写零
//步骤  初始化来找最后一个复写的数 当cur<n 的时候判断cur的位置，如果0
//dest移动两位，否则移动一位，判断dest是否越界到n，如果越界，n-1修改0，并且dest
//向前移动两位，cur向后移动一位从cur位置开始向前遍历原数组，依次还原复写后的数组
//判断cur位置的值，如果是0，dest 以及 dest-1 的位置修改为0，dest-=2
//如果非0，dest的位置修改成0，dest-=1；然后cur--复写下一个位置
//#include<bits/stdc++.h>
//using namespace std;
//class solution
//{
//public:
//	void duplicatezeros(vector<int>& arr)
//		//1找最后一个数
//		int cur = 0, dest = -1, n = arr.size();
//	while (cur < n)
//	{
//		if (arr[cur])dest++;
//		else dest += 2;
//		if (dest >= n - 1)break;//找到了
//		cur++;
//	}
//	//处理边界
//	if (dest == n)
//	{
//		arr[n - 1] = 0;
//		cur--; dest -= 2;
//	}
//	//从后往前依次复写
//	while (cur >= 0)
//	{
//		if (arr[cur])arr[dest--] = arr[cur--];
//		else
//		{
//			arr[dest--] = 0;
//			arr[dest--] = 0;
//			cur--;
//		}
//	}
//};

//快乐数
//class solution
//{
//public:
//	int bitSum(int n)
//		int sum = 0;
//	while (n)
//	{
//		int t = n % 10;
//		sum += t * t;
//		n /= 10;
//	}
//	bool isHappy(int n)
//	{
//		int slow = n, fast = bitSum(n);
//		while (slow != fast)
//		{
//			slow = bitSum(slow);
//			fast = bitSum(bitSum(fast));
//		}
//		return slow == 1;
//	}
//};
//#include <iostream>
//
//using namespace std;
//
//int main()
//{
//    int a = 10;
//    int& p = a;
//
//    p += 5;
//    cout << a << endl;
//
//    return 0;
//}


//#include <iostream>
//#include <string>
//using namespace std;
//int main()
//{
//	string s("abcdef");
//	char str[20];
//
//	//copy(str, n, pos)复制pos位置开始的n个字符到str字符串
//	size_t length = s.copy(str, 4, 2);
//	//copy函数不会在复制内容的末尾附加'\0'，需要手动加
//	str[length] = '\0';
//	cout << str << endl; //dcef
//	return 0;
//}
//快乐数
//#include<bits/stdc++.h>
//using namespace std;
//class Solution
//{
//public:
//	int bitSum(int n)
//		int sum = 0;
//	while (n)
//	{
//		int t = n % 10;
//		sum += t * t;
//		n /= 10;
//	}
//	bool isHappy(int n)
//	{
//		int slow = n, fast = bitSum(n);
//		while (slow != fast)
//		{
//			slow = bitSum(slow);
//			fast = bitSum(bitSum(fast));
//		}
//		return slow == 1;
//	}
//};
//复写零
//从后往前
//class Solution
//{
//public:
//	void duplicateZeros(vector<int>& arr)
	//	int cur = 0, dest = -1, n = arr.size();
	//while (cur < n)
	//{
	//	if (arr[cur]) dest++;//说明不用复写
	//	else dest += 2;
	//	if (dest >= n - 1)break;
	//	cur++;
	//}
	////出来的时候cur就是莫位置
	////处理边界
	//if (dest == n)
	//{
	//	arr[n - 1] = 0;
	//	cur--; dest -= 2;
	//}
	////从后往前面复写
	//while (cur >= 0)
	//{
	//	if (arr[cur])//非0
	//		arr[dest--] = arr[cur--];
	//	else//为0
	//	{
	//		arr[dest--] = 0;
	//		arr[dest--] = 0;
	//		cur--;
	//	}
	//}
};

//移动0
//class Solution
//{
//public:
//	void moveZeros(vector<int>& nums)
//	{
//		for (int cur = 0, dest = -1; cur < nums.size(); cur++)
//		{
//			if (nums[cur])//非零
//				swap(nums[++dest], nums[cur]);
//		}
//	}
//};

//两边之和大于第三边，两边只差小于第三边，同时满足则是
//class Solution {
//public:
//	vector<int> twoSum(vector<int>& price, int target) 
//	{
//		int cur1 = 0, cur2 = 1;
//		while (((price[cur1] + price[cur2]) != target)&&(cur1<price.size()))
//		{
//			if (cur2 < price.size())
//			{
//				cur2++;
//			}
//			else
//			{
//				cur1++;
//				cur2 = cur1 + 1;
//			}
//		}
//	}
//};
//class Solution {
//public:
//	int maxArea(vector<int>& height) {
//		int n = height.size();
//		int ret = 0;
//		// 两层 for 枚举出所有可能出现的情况
//		for (int i = 0; i < n; i++) {
//			for (int j = i + 1; j < n; j++) {
//				// 计算容积，找出最⼤的那⼀个
//				ret = max(ret, min(height[i], height[j]) * (j - i));
//			}
//		}
//		return ret;
//	}
//};

//class Solution
//{
//public:
//	int maxArea(vector<int>& height)
//	{
//		int left = 0, right = height.size() - 1, ret = 0;
//		while (left < right)
//		{
//			int v = min(height[left], height[right]) * (right - left);
//			ret = max(ret, v);
//			// 移动指针
//			if (height[left] < height[right]) left++;
//			else right--;
//		}
//		return ret;
//	}
//};


//class Solution {
//public:
//	int triangleNumber(vector<int>& nums) {
//		// 1. 排序
//		sort(nums.begin(), nums.end());
//		int n = nums.size(), ret = 0;
//		// 2. 从⼩到⼤枚举所有的三元组
//		for (int i = 0; i < n; i++) {
//			for (int j = i + 1; j < n; j++) {
//				for (int k = j + 1; k < n; k++) {
//					// 当最⼩的两个边之和⼤于第三边的时候，统计答案
//					if (nums[i] + nums[j] > nums[k])
//						ret++;
//				}
//			}
//		}
//		return ret;
//	}
//};

//class Solution
//{
//public:
//	int triangleNumber(vector<int>& nums)
//	{
//		// 1. 优化
//		sort(nums.begin(), nums.end());
//		// 2. 利⽤双指针解决问题
//		int ret = 0, n = nums.size();
//		for (int i = n - 1; i >= 2; i--) // 先固定最⼤的数
//		{
//			// 利⽤双指针快速统计符合要求的三元组的个数
//			int left = 0, right = i - 1;
//			while (left < right)
//			{
//				if (nums[left] + nums[right] > nums[i])
//				{
//					ret += right - left;
//					right--;
//				}
//				else
//				{
//					left++;
//				}
//			}
//		}
//		return ret;
//	}
//};
